let activeEffect = null;
class Dep {
    constructor() {
        //依赖对象的内部会保存一个副作用的集合
        this.subscribers = new Set();
    }
    depend() {
        //如果当前有活动状态的副作用的话，收集此副作用函数
        if (activeEffect) {
            this.subscribers.add(activeEffect);
        }
    }
    notify() {//通知副作用执行
        this.subscribers.forEach(effect => effect());
    }
}
function effect(fn) {
    activeEffect = fn;
    fn();
    activeEffect = null;
}

function reactive(target) {
    const depsMap = new Map();
    return new Proxy(target, {
        get(target, key) {
            //对象的每一个属性都可以是一个依赖
            //先尝试从map中寻找此key对应的dep实例
            let dep = depsMap.get(key);
            //如果没有找到
            if(!dep){//则创建新的Dep实例
                dep = new Dep();
                depsMap.set(key,dep);
            }
            dep.depend();
            //return target[key];
            return Reflect.get(target,key);
        },
        set(target, key, value) {
            //target[key]=value;
            Reflect.set(target,key,value);
            let dep = depsMap.get(key);
            dep&&dep.notify();
        }
    });
}
const state = reactive({ count: 0 });
effect(() => {
    console.log(state.count)
})
state.count = 1
state.count = 2
/**
 * 上面提到了2个概念
 * 依赖
 * 副作用 以后当依赖发生变化后重新执行的函数
 */